// pages/consult/index.js
const consultService = require('../../services/consult');
const hospitalService = require('../../services/hospital');
const util = require('../../utils/util');

Page({

  /**
   * 页面的初始数据
   */
  data: {
    isLogin: false,
    isLoading: true,
    isEmpty: false,
    conversations: [],
    doctors: []
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    this.checkLoginStatus();
    this.loadRecommendDoctors();
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    this.checkLoginStatus();
    if (this.data.isLogin) {
      this.loadConversations();
    }
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    if (this.data.isLogin) {
      this.loadConversations();
      this.loadRecommendDoctors();
    }
    wx.stopPullDownRefresh();
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },

  /**
   * 检查登录状态
   */
  checkLoginStatus() {
    const token = wx.getStorageSync('token');
    this.setData({
      isLogin: !!token
    });
  },

  /**
   * 加载会话列表
   */
  loadConversations() {
    this.setData({ isLoading: true });
    
    console.log('开始获取会话列表...');
    
    // 获取当前用户信息
    const app = getApp();
    const userInfo = app.globalData.userInfo;
    const userId = userInfo ? userInfo.id : null;
    console.log('当前用户ID:', userId);
    
    // 获取请求所需的信息
    const baseUrl = app.globalData.baseUrl || 'http://localhost:8080/api';
    const token = app.globalData.token;
    
    if (!token) {
      console.error('未找到token，无法请求会话列表');
      this.setData({
        isLoading: false,
        isEmpty: true
      });
      return;
    }
    
    // 直接用wx.request获取会话列表
    wx.request({
      url: `${baseUrl}/consult/conversation/user`,
      header: {
        'Authorization': `Bearer ${token}`
      },
      success: (res) => {
        console.log('会话列表API响应:', res);
        let conversations = [];
        
        // 尝试解析不同格式的返回数据
        if (res.statusCode === 200) {
          if (res.data && Array.isArray(res.data)) {
            conversations = res.data;
          } else if (res.data && res.data.data && Array.isArray(res.data.data)) {
            conversations = res.data.data;
          } else if (res.data && typeof res.data === 'object') {
            // 尝试在对象中找到数组
            for (const key in res.data) {
              if (Array.isArray(res.data[key])) {
                conversations = res.data[key];
                break;
              }
            }
          }
        }
        
        console.log('解析出的会话列表:', conversations);
        
        if (conversations && conversations.length > 0) {
          // 格式化会话数据
          const formattedConversations = conversations.map(item => {
            // 标准化日期格式
            let updateTime = item.updateTime;
            if (updateTime && typeof updateTime === 'string') {
              // 将yyyy-MM-dd HH:mm:ss转换为yyyy/MM/dd HH:mm:ss以兼容iOS
              updateTime = updateTime.replace(/-/g, '/');
            }
            
            return {
              ...item,
              staffName: item.staffName || '医生',
              staffAvatar: item.staffAvatar || '/static/images/doctor-avatar.png',
              lastMessage: item.lastMessage || '暂无消息',
              formattedTime: updateTime ? util.formatFriendlyTime(updateTime) : '刚刚',
              unreadCount: item.unreadCount || 0
            };
          });
          
          this.setData({
            conversations: formattedConversations,
            isEmpty: false,
            isLoading: false
          });
        } else {
          this.setData({
            conversations: [],
            isEmpty: true,
            isLoading: false
          });
        }
      },
      fail: (err) => {
        console.error('获取会话列表失败:', err);
        this.setData({
          conversations: [],
          isEmpty: true,
          isLoading: false
        });
      }
    });
  },

  /**
   * 加载推荐医生
   */
  loadRecommendDoctors() {
    hospitalService.getStaffList(null, 1, 10)
      .then(res => {
        if (res && res.records) {
          this.setData({
            doctors: res.records.slice(0, 5) // 只显示前5个医生
          });
        }
      })
      .catch(err => {
        console.error('获取推荐医生列表失败', err);
      });
  },

  /**
   * 跳转到登录页面
   */
  navigateToLogin() {
    wx.navigateTo({
      url: '/pages/login/login'
    });
  },

  /**
   * 跳转到医生列表
   */
  navigateToDoctorList() {
    wx.navigateTo({
      url: '/pages/hospital/staff'
    });
  },

  /**
   * 跳转到聊天页面
   */
  navigateToChat(e) {
    const id = e.currentTarget.dataset.id;
    // 尝试从会话列表中获取当前会话的状态信息
    let cachedStatus = 0; // 默认假设进行中
    
    // 查找当前会话在列表中的状态
    const conversation = this.data.conversations.find(item => item.id == id);
    if (conversation && conversation.status !== undefined) {
      cachedStatus = parseInt(conversation.status);
      console.log('从会话列表中获取到会话状态:', cachedStatus, '会话ID:', id);
    }
    
    console.log('准备跳转到聊天页面，会话ID:', id, '缓存状态:', cachedStatus);
    
    // 显示加载中提示
    wx.showLoading({
      title: '加载中...',
      mask: true
    });
    
    const app = getApp();
    
    // 先获取会话消息，检查服务器返回的会话状态
    wx.request({
      url: `${app.globalData.baseUrl}/consult/message/${id}`,
      method: 'GET',
      header: {
        'Authorization': `Bearer ${app.globalData.token}`
      },
      success: (res) => {
        console.log('获取消息列表结果:', res);
        
        let conversationStatus = cachedStatus; // 使用缓存的状态作为默认值
        
        // 检查返回数据中是否包含会话状态信息
        if (res.statusCode === 200 && res.data) {
          // 尝试从不同格式的响应中提取会话数据
          let conversation = null;
          if (res.data.data && res.data.data.conversation) {
            conversation = res.data.data.conversation;
          } else if (res.data.conversation) {
            conversation = res.data.conversation;
          }
          
          // 如果找到会话信息并且包含状态
          if (conversation && conversation.status !== undefined) {
            conversationStatus = conversation.status;
            console.log('从消息列表API中获取到会话状态:', conversationStatus);
          } else if (res.data.status !== undefined) {
            // 可能直接在根对象上
            conversationStatus = res.data.status;
            console.log('从响应根对象中获取到会话状态:', conversationStatus);
          }
          
          // 检查是否所有消息都已加载完成
          const records = res.data.data?.records || res.data.records || [];
          if (records.length > 0) {
            // 检查是否有系统消息表明会话已结束
            const hasEndMessage = records.some(msg => 
              (msg.type === 'SYSTEM' || msg.contentType === 2) && 
              msg.content && 
              (msg.content.includes('结束') || msg.content.includes('ended'))
            );
            
            if (hasEndMessage) {
              console.log('从消息内容中检测到会话已结束');
              conversationStatus = 1;
            }
            
            // 检查最后一条消息的时间，如果超过7天，可能已结束
            try {
              const lastMsg = records[records.length - 1];
              if (lastMsg && lastMsg.createTime) {
                const createTime = new Date(lastMsg.createTime.replace(/-/g, '/'));
                const now = new Date();
                const daysDiff = Math.floor((now - createTime) / (1000 * 60 * 60 * 24));
                
                console.log('最后一条消息时间:', createTime, '距今天数:', daysDiff);
                
                if (daysDiff > 7 && conversationStatus !== 1) {
                  console.log('最后一条消息已超过7天，可能会话已结束');
                  conversationStatus = 1;
                }
              }
            } catch (e) {
              console.error('解析消息时间出错:', e);
            }
          }
        }
        
        // 跳转到聊天页面并传递状态
        wx.navigateTo({
          url: `/pages/consult/chat?id=${id}&status=${conversationStatus}`,
          fail: (err) => {
            console.error('无法跳转到聊天页面:', err);
            wx.showToast({
              title: '跳转聊天页面失败',
              icon: 'none'
            });
          }
        });
      },
      fail: (err) => {
        console.error('获取消息列表失败:', err);
        // 获取状态失败时也要跳转，使用缓存状态
        wx.navigateTo({
          url: `/pages/consult/chat?id=${id}&status=${cachedStatus}`,
          fail: (navErr) => {
            console.error('无法跳转到聊天页面:', navErr);
            wx.showToast({
              title: '跳转聊天页面失败',
              icon: 'none'
            });
          }
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  /**
   * 创建新会话
   */
  createNewConsult(e) {
    if (!this.data.isLogin) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }
    
    const staffId = e.currentTarget.dataset.id;
    // 确保staffId是字符串类型，避免JavaScript数字精度问题
    const staffIdStr = String(staffId);
    
    wx.showLoading({
      title: '创建会话中...',
    });
    
    consultService.createConversation(staffIdStr)
      .then(conversationId => {
        console.log('会话创建成功，ID:', conversationId);
        
        // 默认状态为进行中(0)，因为这是新创建的会话
        const conversationStatus = 0;
        console.log('新创建的会话，状态强制设置为进行中(0)');
        
        wx.hideLoading();
        wx.navigateTo({
          url: `/pages/consult/chat?id=${conversationId}&status=${conversationStatus}`,
          fail: (err) => {
            console.error('无法跳转到聊天页面:', err);
            wx.showToast({
              title: '跳转聊天页面失败',
              icon: 'none'
            });
          }
        });
      })
      .catch(err => {
        console.error('创建会话失败', err);
        wx.hideLoading();
        wx.showToast({
          title: '创建会话失败，请重试',
          icon: 'none'
        });
      });
  }
})